listitemfactory: Reorganize vfuncs

Instead of bind/rebind/update/unbind, we now just have update, and the
factories get to interpret that in the way they want.

listitem: Make this a GObject

This splits GtkListItem into 2 parts:

1. GtkListItem
   This is purely a GObject with public API for developers who want to
   populate lists. There is no chance to cause conflict with GtkWidget
   properties that the list implementation assumed control over and
   defines a clear boundary.
2. GtkListItemWidget
   The widget part of the listitem. This is not only fully in control of
   the list machinery, the machinery can also use different widget
   implementations for different list widgets like I inted to for
   GtkColumnView.

builder: Make gtk_builder_extend_with_template() work with objects

This will be relevant later when we introduce GtkListItem which is not a
GtkWidget.

gtk-demo: Add a Coverflow application launcher

This is roughly the simplest demo I could come up with.

But I documented it, so there's your tutorial.

Related: #2214

Add GtkSignalListItemFactory

So the poor Rust users can actually use this.

I would totally not use this ever!

columnview: Allow adding/removing columns

... and make that work in UI files via <child>, too.

gtk-demo: Add a minesweeper demo

The demo shows creating ones own listmodel and using it to fill a grid.

I am totally getting the hang of React btw:
500 lines of logic with no UI code and 100 lines of GtkBuilder XML and
I get a sweet UI.

Add GtkColumnView skeleton

It's just a copy/paste of the listview code with all the internals
gutted. The code doesn't do anything.

wip: Add GtkCoverFlow

The widget mostly works out of the box, but some tweaking may be
necessary (in particular in the theme) and the gtk-demo changes might
require removing before this is production-ready.

listbase: Take over anchor handling

With that, pretty much all code but allocating the widgets is gone from
the gridview and listview.

listbase: Add vfuncs to convert positions to/from coordinates

... and use that to implement PageUp/PageDown.

With that, all keyboard handling has been moved to GtkListBase.

listbase: Move focus moving keybindings here

The focus tracker is not yet moved because that depends on scroll_to()
support and we don't have that yet.
Whoops.
So we use a hack.

Remove gtk_selection_model_user_select_item() again

This reverts commit 6a164ab306dad9096bde736c907494c71086d3c4.

The function was awkward and we now have only one caller again, so we
can fold it back into it.

listbase: Move orientable implementation here

listbase: Move selection handling here

listbase: Move item manager here

Nothing really changes, because both ListView and GridView still keep
self->item_manager around, but it's set up to point at the base's item
manager.

This way we can slowly move things to GtkListBase that need the item
manager (like trackers).

listbase: Move GtkScrollable implementation

Shared code between GtkGridView and GtkListView.

Add GtkListBase

This is a base item for GTK's list widgets so they can share some (read:
hopefully a lot of) code.

gridview: Simplify allocation code

It doesn't fix the bug I'm after, but it looks a lot better.

listview: Port various gridview improvements

- Handle anchor as align + top/bottom
  This fixes behavior for cells that are higher than the view
- Add gtk_list_view_adjustment_is_flipped()
  This should fix RTL handling of horizontal lists
- Fix scrolling
  This should make scrolling more reliable, particularly on short lists
  that are only a few pages long.

demo: Add a file browser demo

gridview: Add move keybindings

gridview: Implement (un)select all

Adds listitem.select-all and listitem.unselect-all actions and installs
the same keybindings as the treeview for those actions.

gridview: Add a focus tracker

... and use that to properly update selections when moving around with
the arrow keys.

gridview: Implement list.scroll-to action

gridview: Add activation

gridview: Implement minimum row height

We only allocate a certain amount of widgets - and we don't want to run
out of them. So we make all widgets high enough for this to never
happen.

gridview: Implement the list.select-item action

selectionmodel: Add gtk_selection_model_user_select_item()

I'm not sure this should be public API because it's incredibly awkward.
But it should definitely be shared between list widget implementations.

gridview: Implement anchors and scrolling

listitemmanager: Handle NULL factory

Just don't call it and create empty listitems.

demo: Use a listview as sidebar

gtk-demo: Introduce awards

We need a way to get a useful listbox, so here we go!

builder: Autofill scope property of listitemfactory

I couldn't come up with a better way to automatically inherit the scope
in the builder list item factory that didn't involve a magic
incantation in the XML file. And I do not want developers to know magic
incantations to do a thing that should pretty much always be done.

builderlistitemfactory: Add scope argument

This way, the scope used when creating builder instances can be
influenced. This way, callbacks can be passed into the factory.

listitemfactory: Make the builder factory properly buildable

Turn the construct arguments into construct properties so that they can
be set from ui files.

listview: Add move keybindings

My god, these are a lot.

And my god, these are complicated to get right.

listview: Add gtk_list_view_get_position_at_y()

listitem: Add "listitem.select" action and keybindings for it

In fact, grab space with all modifiers to toggle selection of the
current item.

listview: Add a focus tracker

This ensures that the row with the input focus always stays available,
even when scrolled out of view.

listview: Implement (un)select all

Adds listitem.select-all and listitem.unselect-all actions and installs
the same keybindings as the treeview for those actions.

listview: Track focus movements and update selection

When focus moves via tab/arrow, we need to select the new item.

listview: Implement activation

- a GtkListview::activate signal
- a GtkListItem::activatable property
- activate list items on double clicks and <Enter> presses

treeexpander: Implement input support

This implements all the keybindings from GtkTreeView that can be
supported.

It does not implement expand-all, because supporting that means
causing the TreeListModel to emit lots of create_model vfuncs which in
turn would cause many items-changed signal which in turn would cause
many signal handlers to run which in turn would make "expand-all" very
reentrant, and I'm uneasy about supporting that.

For the mouse, just add a click gesture to the expander icon that toggles
expanded state.

listitem: Change focus handling

Focus in the listitem now works like this:
1. If any child can take focus, do not ever attempt
   to take focus.
2. Otherwise, if this item is selectable or activatable,
   allow focusing this widget.

This makes sure every item in a list is focusable for
activation and selection handling, but no useless widgets
get focused and moving focus is as fast as possible.

inspector: Make the recorder node list use a ListView

It's quite a bit faster now, but the code is also a bit more awkward.

Pain points:

- GtkTreeListModel cannot be created in UI files because it needs
  a CreateModelFunc.
  Using a signal for this doesn't work because autoexpand wants to
  expand the model before the signal handler is connected.

- The list item factory usage is still awkward. It's bearable here
  because the list items are very simple, but still.

inspector: Use a GtkTreeExpander in the object tree

inspector: Use a treeexpander in the recorder

demo: Add a GSettings tree demo

It is meant to look somewhat like dconf-editor when it is done.

So far, it's just a list.

Add GtkTreeExpander

This is a container widget that takes over all the duties of tree
expanding and collapsing.
It has to be a container so it can capture keybindings while focus is
inside the listitem.

So far, this widget does not allow interacting with it, but it shows the
expander arrow in its correct state.

Also, testlistview uses this widget now instead of implementing
expanding itself.

gridview: Actually do something

Implement measuring and allocating items - which makes the items appear
when drawing and allows interacting with the items.

However, the gridview still does not allow any user interaction
(including scrolling).

listview: Pass the CSS name of listitems to the manager

... instead of hardcoding "row".

gridview: Implement GtkOrientable

Again, this is just the skeleton, because the Gridview does nothing yet.

gridview: Add factory handling

Just copy the listview APIs.

Code still doesn't do anything with it.

listview: Expose GtkListItemFactory APIs

Due to the many different ways to set factories, it makes sense to
expose them as custom objects.

This makes the actual APIs for the list widgets simpler, because they
can just have a regular "factory" property.

As a convenience function, gtk_list_view_new_with_factory() was added
to make this whole approach easy to use from C.

gtk-demo: Add a rough start at a Weather demo

This demos a horizontal listview.

listview: Implement GtkOrientable

tests: Add a rough form of multiselection

Just store a "filechooser::selected" attribute in the GFileInfo if
the file is meant to be selected.

listview: Implement extending selections

Shift-clicking to extend selections now also works, imitating the
behavior of normal clicking and Windows Explorer (but not treeview):

1. We track the last selected item (normally, not via extend-clicking).

2. When shift-selecting, we modify the range from the last selected item
   to this item the same way we modify the regular item when not using
   shift:

2a. If Ctrl is not pressed, we select the range and unselect everything
    else.

2b. If Ctrl is pressed, we make the range have the same selection state
    as the last selected item:
    - If the last selected item is selected, select the range.
    - If the last selected item is not selected, unselect the range.

listview: Add list.scroll_to_item action

The action scrolls the given item into view.

Listitems activate this action when they gain focus.

testlistview: Load icons async

Speeds up loading by 4x, because out of view icons aren't loaded
anymore.

testlistview: Port to directory list

listitemfactory: Add a factory for ui files

Reuse <template> magic to initialize GtkListItems. This feels
amazingly hacky, but it also amazingly worked on the first try.

listitemfactory: Split implementation out

.. into gtkfunctionslistitemfactory.c

Now we can add a different implmenetation.

listitemfactory: vfuncify

No functional changes other than a new indirection.

listitemfactory: Sanitize APIs

Make sure the APIs follow a predictable path:

setup
  bind
    rebind/update (0-N times)
  unbind
teardown

This is the first step towards providing multiple different factories.

listview: Add gtk_list_view_set_show_separators()

Do the same thing that GtkListBox does in commit
0249bd4f8a03ec473f3ca9d4324a3a8b75bd3f44

listitemmanager: Add trackers

... and replace the anchor tracking with a tracker.

Trackers track an item through the list across changes and ensure that
this item (and potentially siblings before/after it) are always backed
by a GtkListItem and that if the item gets removed a replacement gets
chosen.

This is now used for tracking the anchor but can also be used to add
trackers for the cursor later.

listitemmanager: Simplify

Remove a bunch of API from the headers that isn't used anymore and then
refactor code to not call it anymore.

In particular, get rid of GtkListItemManagerChange and replace it with a
GHashTable.

gridview: Implement GtkScrollable

We can now scroll all the nothing we display.

We also clip it properly.

listitemmanager: Move list of listitems here

All the listview infrastructure moved with it, so the next step is
moving that back...

gridview: Add API for setting number of columns

The API isn't used yet.

gtk: Add a GtkGridView skeleton

listitem: Add a press gesture to select the item

This is implemented by using actions, which are a neat trick to get to
allow the ListItem to call functions on the ListView without actually
needing to be aware of it.

listview: Add initial support for displaying selections

listview: Reset listitems' CSS animations when rebinding

This way, newly displayed rows don't play an unselect animation (text
fading in) when they are unselected, but the row was previously used for
a selected item.

listview: Add selection properties to ListItem

This just brings the infrastructure into place, we're not using the
properties yet.

listview: Try to keep the list items in order when scrolling

Instead of just destroying all items and then recreating them (or even
hide()ing and then show()ing them again (or even even repositioning
them in the widget tree)), just try to reust them in the order they are.

This works surprisingly well when scrolling and most/all widgets
just moved.

listlistmodel: Add gtk_list_list_model_item_moved()

Use it to fix a case that just said g_warning ("oops").

Apparently I had forgotten the case where a container moved a child
in the widget tree.

listitemmanager: Switch from "insert_before" to "insert_after" argumnet

We reorder widgets start to end, so when reusing a list item, we
correctly know the previous sibling for that list item, but not the
next sibling yet. We just know the widget it should ultimately be in
front of.
So we can do a more correct guess of the list item's place in the widget
tree if we think about where to place an item like this.

Actually using this change will come in the next commit.

testlistview: Create widgets only once

Previously, we were recreating all widgets every time the list item was
rebound, which caused a lot of extra work every time we scrolled.

Now we keep the widgets around and only set their properties again when
the item changes.

testlistview: Show the row number

Always show the current row. This is mostly useful for debugging, not
for beauty.

listview: Only allocate necesary rows

This is the big one.

The listview only allocates 200 rows around the visible row now.
Everything else is kept in ListRow instances with row->widget == NULL.

For rows without a widget, we assign the median height of the child
widgets as the row's height and then do all calculations as if there
were widgets that had requested that height (like setting adjustment
values or reacting to adjustment value changes).

When the view is scrolled, we bind the 200 rows to the new visible area,
so that the part of the listview that can be seen is always allocated.

listview: Change anchor handling again

The anchor is now a tuple of { listitem, align }.

Using the actual list item allows keeping the anchor across changes
in position (ie when lists get resorted) while still being able to fall
back to positions (list items store their position) when an item gets
removed.

The align value is in the range [0..1] and defines where in the visible
area to do the alignment.
0.0 means to align the top of the row with the top of the visible area,
1.0 aligns the bottom of the widget with the visible area and 0.5 keeps
the center of the widget at the center of the visible area.
It works conceptually the same as percentages in CSS background-position
(where the background area and the background image's size are matched
the same way) or CSS transform-origin.

listview: Change how binding is done

We now don't let the functions create widgets for the item from the
listmodel, instead we hand out a GtkListItem for them to add a widget
to.

GtkListItems are created in advance and can only be filled in by the
binding code by gtk_container_add()ing a widget.
However, they are GObjects, so they can provide properties that the
binding code can make use of - either via notify signals or GBinding.

listitem: Add gtk_list_item_get_position()

Also refactor the whole list item management yet again.

Now, list item APIs doesn't have bind/unbind functions anymore, but only
property setters.

The item factory is the only one doing the binding.
As before, the item manager manages when items need to be bound.

tests: Make animating listview do random resorts

listview: Change change management

Add a GtkListItemManagerChange object that tracks all removed list
rows during an item-changed signal so they can be added back later.

listview: Make the listitemmanager stricter

Require that items created with the manager get destroyed via the
manager.

To that purpose, renamed create_list_item() to acquire_list_item() and
add a matching release_list_item() function.

This way, the manager can in the future keep track of all items and
cache information about them.

listview: Add GtkListItem

GtkListItem is a generic row widget that is supposed to replace
GtkListBoxRow and GtkFlowBoxChild.

listview: Add GtkListItemManager

It's all stubs for now, but here's the basic ideas about what
this object is supposed to do:

(1) It's supposed to be handling all the child GtkWidgets that are
    used by the listview, so that the listview can concern
    itself with how many items it needs and where to put them.
(2) It's meant to do the caching of widgets that are not (currently)
    used.
(3) It's meant to track items that remain in the model across
    items-changed emissions and just change position.
(2) It's code that can be shared between listview and potential
    other widgets like a GridView.

It's also free to assume that the number of items it's supposed to
manage doesn't grow too much, so it's free to use O(N) algorithms.

listview: Implement an anchor

The anchor selection is very basic: just anchor the top row.

That's vastly better than any other widget already though.

tests: Add a test for a permanently changing listview

This is mostly for dealing with proper anchoring and can be used to
check that things don't scroll or that selection and focus handling
properly works.

For comparison purposes, a ListBox is provided next to it.

listview: Implement GtkScrollable

Scrolling in a very basic form is also supported

listview: Make widget actually do something

The thing we're actually doing is create and maintain a widget for every
row. That's it.

Also add a testcase using this. The testcase quickly allocates too many
rows though and then becomes unresponsive though. You have been warned.

listview: Introduce GtkListItemFactory

Thisis the abstraction I intend to use for creating widgets and binding
them to the item out of the listview.

For now this is a very dumb wrapper around the functions that exist in
the API.

But it leaves the freedom to turn this into public API, make an
interface out of it and most of all write different implementations, in
particular one that uses GtkBuilder.

gtk: Add a GtkListView skeleton

builder: Add <binding> tag

The tag contains an expression that it then gtk_expression_bind()s to
the object it is contained in.

builder: Allow text content in <lookup>

  <lookup>foo</lookup>
is now short for
  <lookup>
    <constant>foo</constant>
  </lookup>
ie it looks up the object with the given name so it can then do a
property lookup with it.

This is the most common operation, so it's a nice shortcut.

builder: Allow <constant> without a type

A constant without a type is assumed to be an object. This is the most
common case and allows
  <constant>foo</constant>
without requiring updates to the type whenever the foo object changes.